home *** CD-ROM | disk | FTP | other *** search
/ ShareWare OnLine 2 / ShareWare OnLine Volume 2 (CMS Software)(1993).iso / linux / slsv1aa3.zip / FONTPAK.TPZ / FONTPAK.tar / usr / src / fontpak / console.dif next >
Text File  |  1993-02-27  |  11KB  |  397 lines
  1. *** console.c.sav    Sat Feb 27 17:12:44 1993
  2. --- console.c    Sat Feb 27 17:25:13 1993
  3. ***************
  4. *** 1,3 ****
  5. --- 1,4 ----
  6. + #define CODEPAGE
  7.   /*
  8.    *  linux/kernel/console.c
  9.    *
  10. ***************
  11. *** 67,72 ****
  12. --- 68,90 ----
  13.   static char sel_buffer[SEL_BUFFER_SIZE] = { '\0' };
  14.   #endif /* SELECTION */
  15.   
  16. + #ifdef DEBUG
  17. + void console_print(const char * b);
  18. + #endif
  19. + #ifdef CODEPAGE
  20. + void save_font_zero( void );
  21. + int vc_activate_cp( int currcons, int whichcp );
  22. + static unsigned long    charmap_mem_base;       /* base of vga character map memory */
  23. + static unsigned short   sequencer_port_reg;
  24. + static unsigned short   sequencer_port_val;
  25. + static unsigned short   graphics_port_reg;
  26. + static unsigned short   graphics_port_val;
  27. + static int can_do_cp = 0;
  28. + static int cp;
  29. + static int cp_i;
  30. + static int cp_count;
  31. + #endif
  32. + 
  33.   #define NPAR 16
  34.   
  35.   extern void vt_init(void);
  36. ***************
  37. *** 114,119 ****
  38. --- 132,140 ----
  39.       /* attribute flags */
  40.       unsigned long    vc_intensity    : 2;    /* 0=half-bright, 1=normal, 2=bold */
  41.       unsigned long    vc_underline    : 1;
  42. + #ifdef CODEPAGE
  43. +     int             vc_codepage; /* offset into internal codepage info */
  44. + #endif
  45.       unsigned long    vc_blink    : 1;
  46.       unsigned long    vc_reverse    : 1;
  47.       unsigned long    vc_s_intensity    : 2;    /* saved rendition */
  48. ***************
  49. *** 133,138 ****
  50. --- 154,165 ----
  51.       /* additional information is in vt_kern.h */
  52.   } vc_cons [NR_CONSOLES];
  53.   
  54. + #ifdef CODEPAGE
  55. + #define CP_BUFFER_SIZE (256*32)
  56. + #define MAX_CPs 3
  57. + char cp_buffers[ MAX_CPs * CP_BUFFER_SIZE ];
  58. + #endif
  59. + 
  60.   #define MEM_BUFFER_SIZE (2*80*50*8) 
  61.   
  62.   unsigned short *vc_scrbuf[NR_CONSOLES];
  63. ***************
  64. *** 175,180 ****
  65. --- 202,211 ----
  66.   #define charset        (vc_cons[currcons].vc_charset)
  67.   #define s_charset    (vc_cons[currcons].vc_s_charset)
  68.   #define    intensity    (vc_cons[currcons].vc_intensity)
  69. + #ifdef CODEPAGE
  70. + #define codepage        (vc_cons[currcons].vc_codepage)
  71. + #endif
  72. + 
  73.   #define    underline    (vc_cons[currcons].vc_underline)
  74.   #define    blink        (vc_cons[currcons].vc_blink)
  75.   #define    reverse        (vc_cons[currcons].vc_reverse)
  76. ***************
  77. *** 858,868 ****
  78.       need_wrap = 0;
  79.   }
  80.   
  81.   enum { ESnormal, ESesc, ESsquare, ESgetpars, ESgotpars, ESfunckey, 
  82. !     EShash, ESsetG0, ESsetG1, ESignore };
  83.   
  84.   static void reset_terminal(int currcons, int do_clear)
  85.   {
  86.       top        = 0;
  87.       bottom        = video_num_lines;
  88.       state        = ESnormal;
  89. --- 889,908 ----
  90.       need_wrap = 0;
  91.   }
  92.   
  93. + #ifndef CODEPAGE
  94. + enum { ESnormal, ESesc, ESsquare, ESgetpars, ESgotpars, ESfunckey, 
  95. +     EShash, ESsetG0, ESsetG1, ESignore};
  96. + #else
  97.   enum { ESnormal, ESesc, ESsquare, ESgetpars, ESgotpars, ESfunckey, 
  98. !     EShash, ESsetG0, ESsetG1, ESignore, EScodepage0, EScodepage1,
  99. !     EScpPROG, EScpPROG1, EScpPROG2, EScpUSE };
  100. ! #endif
  101.   
  102.   static void reset_terminal(int currcons, int do_clear)
  103.   {
  104. + #ifdef CODEPAGE
  105. +     codepage = 0;
  106. + #endif
  107.       top        = 0;
  108.       bottom        = video_num_lines;
  109.       state        = ESnormal;
  110. ***************
  111. *** 930,936 ****
  112. --- 970,981 ----
  113.               }
  114.               if (decim)
  115.                   insert_char(currcons);
  116. + #ifdef CODEPAGE
  117. +             if( !codepage )
  118. +                 c=translate[ c ];
  119. + #else
  120.               c = translate[c];
  121. + #endif
  122.               *(char *) pos = c;
  123.               *(char *) (pos+1) = attr;
  124.               if (x == video_num_columns - 1)
  125. ***************
  126. *** 994,999 ****
  127. --- 1039,1049 ----
  128.               case ESesc:
  129.                   state = ESnormal;
  130.                   switch (c) {
  131. + #ifdef CODEPAGE
  132. +                                   case 'F':             /* We have ESC-F.  Codepage stuff! */
  133. +                                         state = EScodepage0;
  134. +                                         continue;
  135. + #endif
  136.                     case '[':
  137.                       state = ESsquare;
  138.                       continue;
  139. ***************
  140. *** 1209,1214 ****
  141. --- 1259,1265 ----
  142.                       G1_charset = GRAF_TRANS;
  143.                   else if (c == 'B')
  144.                       G1_charset = NORM_TRANS;
  145. + 
  146.                   else if (c == 'U')
  147.                       G1_charset = NULL_TRANS;
  148.                   if (charset == 1)
  149. ***************
  150. *** 1215,1220 ****
  151. --- 1266,1354 ----
  152.                       translate = G1_charset;
  153.                   state = ESnormal;
  154.                   continue;
  155. + #ifdef CODEPAGE
  156. +             case EScodepage0:        /* we have ESC-ESC-ESC */
  157. +             switch( c )
  158. +                 {
  159. +                 case 'P':    
  160. +                 state = EScpPROG;
  161. +                 continue;
  162. + 
  163. +                 case 'U':
  164. +                 state = EScpUSE;
  165. +                 continue;
  166. + 
  167. +                 default:
  168. +                 state = ESnormal;
  169. +                 }
  170. +             continue;
  171. + 
  172. +             case EScpPROG:
  173. +             /* We Now have ESC-F-P.  The next byte is the codepage that
  174. +                 needs to be programmed */
  175. +             cp = c - '0'; /* let us use ascii number */
  176. +             if( cp > 0 && cp < MAX_CPs )
  177. +                 {
  178. +                 /*********************************************
  179. +                 We now have ESC-F-P-<NUMBER>, where number is
  180. +                 the ascii for a valid codepage number. The next
  181. +                 8192*2 characters are assumed to  be codepage
  182. +                 data bytes, expressed in hexadecimal.
  183. +                 **********************************************/
  184. +                 state = EScpPROG1;
  185. +                 /* point to eh beginning of the current buf */
  186. +                 cp_i = cp * CP_BUFFER_SIZE;
  187. +                 cp_count = 0;
  188. +                 }
  189. +             else state = ESnormal;
  190. +             continue;
  191. + 
  192. +             case EScpPROG1:
  193. +             /*****************************************************
  194. +             We are receiving data bytes.  To keep things ASCII,
  195. +             there are two characters for each byte of binary data.
  196. +             This is the case for the  bytes ( first, third, fifth,
  197. +             etc ), and ESCcpPROG2 is the  for the even bytes
  198. +             ( second, fourth, etc ).  Of course, the 
  199. +             writes to the font buffer take place on the EVEN bytes.
  200. +             *****************************************************/
  201. +             c -= '0';/* ascii hexadecimal to binary conversion */
  202. +             if( c>9 ) c-=7;
  203. +             cp_buffers[ cp_i ] = c;
  204. +             state = EScpPROG2;
  205. +             continue;
  206. + 
  207. + 
  208. +             case EScpPROG2:
  209. +             /******************************************************
  210. +             This state is for the even-# codepage data bytes.....
  211. +             ******************************************************/
  212. +             c -= '0';
  213. +             if( c>9 ) c-=7;
  214. +             cp_buffers[ cp_i ] *= 0x10;  /* move the odd data up */
  215. +             /* move the new ( even ) data into the lower nybble */
  216. +             cp_buffers[ cp_i++ ] += c;
  217. +             if( ++cp_count == CP_BUFFER_SIZE )
  218. +               {
  219. +               state = ESnormal;
  220. +               }
  221. +             else state = EScpPROG1;
  222. +             continue;
  223. + 
  224. +             case EScpUSE:
  225. +             /*****************************************************
  226. +             We now have ESC-F-U. We still need to know which
  227. +             codepage we are to use. Choice is zero to MAX_CPs - 1
  228. +             ******************************************************/
  229. +             cp = c - '0';
  230. +             if( cp < MAX_CPs )
  231. +                 {
  232. +                 vc_activate_cp( currcons, cp );
  233. +                 }
  234. +             state = ESnormal;
  235. +             continue;
  236. + 
  237. + #endif  /* CODEPAGE? */
  238.               default:
  239.                   state = ESnormal;
  240.           }
  241. ***************
  242. *** 1310,1315 ****
  243. --- 1444,1459 ----
  244.               video_type = VIDEO_TYPE_EGAC;
  245.               video_mem_term = 0xc0000;
  246.               display_desc = "EGA+";
  247. + #ifdef CODEPAGE
  248. +                 can_do_cp = 1;
  249. +             charmap_mem_base = 0xa0000;
  250. + 
  251. +             sequencer_port_reg = 0x3c4;
  252. +             sequencer_port_val = 0x3c5;
  253. +             graphics_port_reg = 0x3ce;
  254. +             graphics_port_val = 0x3cf;
  255. +             save_font_zero();
  256. + #endif
  257.           }
  258.           else
  259.           {
  260. ***************
  261. *** 1351,1356 ****
  262. --- 1495,1503 ----
  263.       gotoxy(currcons,orig_x,orig_y);
  264.       update_screen(fg_console);
  265.       printable = 1;
  266. + #ifdef CODEPAGE
  267. +     if( can_do_cp ) codepage=0;
  268. + #endif
  269.       printk("Console: %s %s %dx%d, %d virtual consoles\n",
  270.           can_do_color?"colour":"mono",
  271.           display_desc,
  272. ***************
  273. *** 1424,1429 ****
  274. --- 1571,1579 ----
  275.       fg_console = new_console;
  276.       set_scrmem(fg_console); 
  277.       set_origin(fg_console);
  278. + #ifdef CODEPAGE
  279. +     vc_activate_cp( new_console, vc_cons[new_console].vc_codepage );
  280. + #endif
  281.       set_cursor(new_console);
  282.       set_leds();
  283.       lock = 0;
  284. ***************
  285. *** 1519,1524 ****
  286. --- 1669,1778 ----
  287.           return -ENODEV;
  288.       return 0;
  289.   }
  290. + 
  291. + #ifdef CODEPAGE
  292. + 
  293. +  /*
  294. +   * Program EGA sequencer and graphics controller to access downloadable
  295. +   * font region.  From _Video Systems_, p. 307.
  296. +   */
  297. +  
  298. + void setsf( void )
  299. +     {
  300. +     cli();
  301. +     outb_p( 0x00, sequencer_port_reg );   /* First, the sequencer */
  302. +     outb_p( 0x01, sequencer_port_val );   /* Synchronous reset */
  303. +     outb_p( 0x02, sequencer_port_reg );   
  304. +     outb_p( 0x04, sequencer_port_val );   /* CPU writes only to map 2 */
  305. +     outb_p( 0x04, sequencer_port_reg );
  306. +     outb_p( 0x07, sequencer_port_val );   /* Sequential addressing */
  307. +     outb_p( 0x00, sequencer_port_reg );
  308. +     outb_p( 0x03, sequencer_port_val );   /* Clear synchronous reset */
  309. +               
  310. +     outb_p( 0x04, graphics_port_reg );    /* Now, the graphics controller */
  311. +     outb_p( 0x02, graphics_port_val );    /* select map 2 */
  312. +     outb_p( 0x05, graphics_port_reg );    
  313. +     outb_p( 0x00, graphics_port_val );    /* disable odd-even addressing */
  314. +     outb_p( 0x06, graphics_port_reg );    
  315. +     outb_p( 0x00, graphics_port_val );    /* map start at A000:0000 */
  316. +     sti();
  317. +     }
  318. +     
  319. +     
  320. +     /*
  321. +     * Program EGA back the way it was, for ordinary text operations.
  322. +     * (If the screen was in graphics mode we're up a creek.)
  323. +     * From _Video Systems_, p. 307.
  324. +     */
  325. +     
  326. + void unsetsf( void )
  327. +     {
  328. +     cli();
  329. +     outb_p( 0x00, sequencer_port_reg );   /* Frist, the sequencer */
  330. +     outb_p( 0x01, sequencer_port_val );   /* Synchronous reset */
  331. +     outb_p( 0x02, sequencer_port_reg );   
  332. +     outb_p( 0x03, sequencer_port_val );   /* CPU writes to maps 0 and 1 */
  333. +     outb_p( 0x04, sequencer_port_reg );   
  334. +     outb_p( 0x03, sequencer_port_val );   /* odd-even addressing */
  335. +     outb_p( 0x00, sequencer_port_reg );   
  336. +     outb_p( 0x03, sequencer_port_val );   /* clear synchronous reset */
  337. +     
  338. +     outb_p( 0x04, graphics_port_reg );    /* Now, the graphics controller */
  339. +     outb_p( 0x00, graphics_port_val );    /* select map 0 for CPU */
  340. +     outb_p( 0x05, graphics_port_reg );    
  341. +     outb_p( 0x10, graphics_port_val );    /* enable even-odd addressing */
  342. +     outb_p( 0x06, graphics_port_reg );    
  343. +     outb_p( 0x0e, graphics_port_val );    /* map starts at b800:0000 */
  344. +     sti();
  345. +     }
  346. +     
  347. +     
  348. + /*************************************
  349. + int vc_progcp( int whichcp, char *data ) 
  350. +     {
  351. +     unsigned long tmp = cp_buffers;
  352. +     tmp += (whichcp*256*32);
  353. +     if(( whichcp < MAX_CPs) && (whichcp > 0))
  354. +         {
  355. +         memcpy((void *) tmp,(void *)data,256*32);
  356. +         return(0);
  357. +         }
  358. +     else return (-EINVAL);
  359. +     }
  360. + ******************************************/
  361. +     
  362. + void load_cp( int whichcp )
  363. +     {
  364. +     void *tmp_p = cp_buffers;
  365. + 
  366. +     tmp_p += ( whichcp * 256 * 32 );
  367. +     setsf();                          /* enable EGA access */
  368. +     memcpy( (void *) charmap_mem_base, tmp_p, 256*32 ); /* do it */
  369. +     unsetsf();     /*disable EGA access*/
  370. +     }
  371. +     
  372. + int vc_activate_cp( int currcons, int whichcp )
  373. +     {
  374. +     if(( whichcp < MAX_CPs ) && ( currcons < NR_CONSOLES ))
  375. +         {
  376. +         codepage = whichcp;
  377. +         if( currcons == fg_console ) load_cp( whichcp );
  378. +         return (0);
  379. +         }
  380. +     else return (-EINVAL);
  381. +     }
  382. +     
  383. +     
  384. + void save_font_zero( void )
  385. +     {
  386. +     if( can_do_cp )
  387. +         {
  388. +         setsf();
  389. +         memcpy((void *)cp_buffers, (void *) charmap_mem_base, ( 256*32 ));
  390. +         unsetsf();
  391. +         }
  392. +     }
  393. + #endif /* CODEPAGE? */
  394.   
  395.   #ifdef SELECTION
  396.   /* set reverse video on characters s-e of console with selection. */
  397.